import { ref, computed } from 'vue'
import { defineStore } from 'pinia'
import { ElNotification } from 'element-plus';
import { importData, queryHwData, getAllData, batchUpdate, exceptionData } from '@/axios/api'

import battle from '@/assets/battle.wav'; // 导入音频文件
import fail from '@/assets/fail.wav'; // 导入音频文件
import ttsmaker from '@/assets/ttsmaker.mp3'; // 导入音频文件
import empty from '@/assets/empty.mp3'; // 导入音频文件
import hwmp3 from '@/assets/hw.mp3'; // 导入音频文件
import a from '@/assets/a.mp3'; // 导入音频文件
import b from '@/assets/b.mp3'; // 导入音频文件
import c from '@/assets/c.mp3'; // 导入音频文件




const useCounterStore = defineStore('scan', () => {
  const audioSrc = ref(battle); // 使用ref绑定音频文件路径，这样可以动态修改音频文件路径
  let loading = ref(false); // 控制加载导入动画
  let loading_out = ref(false); // 控制加载导出动画
  const ucantable = ref<any>([]) // 存储未扫描的货位数据
  const scantable = ref<any>([]) // 存储已扫描的货位数据
  let scandata = ref<string>(''); // 存储扫描的数据
  let notInArraydata = ref<any>([]); // 存储异常扫描的数据
  let sn = ref(''); // 存储扫描的条码号
  let hw = ref(''); // 存储扫描的货位号
  let total = ref(0);  // 存储扫描的货位的总数量
  let flags=false; // 控制文件是否被锁定

  // 加载音频文件
  function loadAndPlay(audioPlayer: any) {
    audioPlayer.load(); // 加载新的音频
    audioPlayer.pause();
    audioPlayer.currentTime = 0;
    // 当音频文件加载完成并且可以无缓冲播放时，再播放音频
    audioPlayer.oncanplaythrough = () => {
      audioPlayer.play().catch((error: any) => {
        console.error('播放音频失败:', error);
      });
    };
  }
  // 播放音频
  function play(audioPlayer: any) {
    try {
      loadAndPlay(audioPlayer);
    } catch (e) {
      loadAndPlay(audioPlayer);
    }
  }

  // 回车键触发表单提交事件
  async function ScanEnter(audioPlayer: any) {
    try {
      flags=false;
      if (scandata.value == '') {
        showError('扫描数据不能为空');
      }
      else if (!scandata.value.includes(',') && scandata.value.includes('-')) {
        console.log(scandata.value)
        // 处理货位号扫描逻辑
        await handleHwScan();
      } else {
        // 处理条码扫描逻辑
        await handleSnScan();
      }

    } catch (error: any) {
      ElNotification({
        title: 'Error',
        message: error,
        type: 'error',
      })
    } finally {
      play(audioPlayer);
    }
  }
  // 处理货位号扫描逻辑
  async function handleHwScan() {
    hw.value = scandata.value.trim();
    try {
      let res = await queryHwData(hw.value);
      if (res.code == 200) {
        notInArraydata.value = [];

        total.value = res.data.length;
        ucantable.value = res.data.filter((item: any) => item.isscan == 0);
        scantable.value = res.data.filter((item: any) => item.isscan == 1);
        scandata.value = '';
        if (ucantable.value.length == 0) {
          showError('这个货位没有未扫描的条码');
        } else {
          showError('货位扫描成功');
        }
        return 'ok';
      } else {
        showError(res.message);
      }
    } catch (error) {
      showError('查询失败');
    }
  }
  // 处理条码扫描逻辑
  async function handleSnScan() {
    try {
      
      if (hw.value == '') {
        showError('请先扫描货位');
        return;
      }
      // 创建一个空数组来存储分割后的内容
      const commaBeforeParts: any = [];
      // 循环遍历每一行内容，
      const linesArray = scandata.value.split(/\s+/);
      linesArray.forEach(line => {
        const parts = line.split(',');
        if (parts.length > 0) {
          commaBeforeParts.push(parts[0]);
        }
      });

      let arrayB: any = [];// 存储未扫描的条码的数组
      arrayB = ucantable.value.map((obj: any) => obj.sn);
      // 循环遍历每一行内容，
      // 并判断是否在未扫描的条码数组中，如果在，则将条码添加到已扫描数组中，否则添加到未扫描数组中
      const { inArray, notInArray } = commaBeforeParts.reduce((acc: any, item: string) => {
        if (arrayB.includes(item)) {
          acc.inArray.push(item.trim()); // 条码存在，添加到待提交的数组中
        } else {
          if (item.trim().length > 0) {
            acc.notInArray.push(item); // 条码不存在，添加到异常数组中
          }
        }
        return acc;
      }, { inArray: [], notInArray: [] });

      // 如果有异常条码，则将异常条码添加到异常表格中
      if (notInArray.length > 0) {
        notInArray.forEach((item: string) => {
          notInArraydata.value.push({ sn: item });

        });
        // 把异常条码和货位号一起发送到后端
        try {
          let res = await exceptionData({ hw: hw.value, sn: notInArray });
          if (res.code == 200) {
            ElNotification({
              title: 'Success',
              message: '异常数据已写入异常表',
              type: 'success',
            });
          }else if(res.code == 208){
            flags=true;
            showError('文件已被锁定，异常数据写入表格失败');
          }else {
            showError('异常数据写入表格失败');
          }

        } catch (error: any) {
          showError('异常数据写入表格失败');
        }

      }
      // 如果有条码需要提交，则提交数据
      if (inArray.length > 0) {
        let data = {
          sn: inArray
        }
        let res = await batchUpdate(data);
        if (res.code == 200) {
          // 成功扫描，将货位从未扫描数组中移除，并添加到已扫描数组中
          inArray.forEach((item: string) => {
            for (let i = ucantable.value.length - 1; i >= 0; i--) {
              if (ucantable.value[i].sn === item) {
                scantable.value.push(ucantable.value[i]);
                ucantable.value.splice(i, 1);
              }
            }
          });
          scandata.value = '';
          sn.value = '';
          if (unscan.value > 0) {
            audioSrc.value = battle;
          } else {
            audioSrc.value = b;
          }
        } else {
          showError('更新失败');
        }
      } else {
        if (flags==false) {
          showError('条码不存在');
        }
        
      }
    } catch (error: any) {
      if (flags==false) {
        showError('扫描失败');
      }
     
    }
  }
  // 显示错误信息
  function showError(message: any) {
    scandata.value = '';
    sn.value = '';
    if (message == '扫描数据不能为空') {
      audioSrc.value = empty;
    } else if (message == '请先扫描货位') {
      audioSrc.value = ttsmaker;
    } else if (message == '货位扫描成功') {
      audioSrc.value = hwmp3;
      return;
    } else if (message == '这个货位没有未扫描的条码') {
      audioSrc.value = a;
      return;
    } else if (message == '文件已被锁定，异常数据写入表格失败') {
      audioSrc.value = c;
      return;
    } else {
      audioSrc.value = fail;
    }
    ElNotification({
      title: 'Error',
      message: message,
      type: 'error',
    });

  }
  // 计算未扫描数量
  let unscan = computed(() => {
    return ucantable.value.length;
  });
  //计算已扫描数量
  let scaned = computed(() => {
    return scantable.value.length;
  });
  // 导入数据
  async function useimportData() {
    try {
      loading.value = true;
      let res = await importData();
      if (res.code == 200) {
        ElNotification({
          title: 'Success',
          message: res.message,
          type: 'success',
        });
        loading.value = false;
      } else {
        loading.value = false;
        ElNotification({
          title: 'Error',
          message: '导入失败',
          type: 'error',
        })
      }
    } catch (error) {
      loading.value = false;
      ElNotification({
        title: 'Error',
        message: '导入失败',
        type: 'error',
      })
    }
  }
  // 导出数据

  async function useioutData() {
    try {
      loading_out.value = true;
      let res = await getAllData();
      if (res.code == 200) {
        ElNotification({
          title: 'Success',
          message: '导出成功',
          type: 'success',
        });
        loading_out.value = false;
        return ('ok');
      } else {
        loading_out.value = false;
        ElNotification({
          title: 'Error',
          message: res.message,
          type: 'error',
        });
        return Promise.reject(new Error('导出失败'));
      }
    } catch (error: any) {
      loading_out.value = false;
      ElNotification({
        title: 'Error',
        message: '导出失败',
        type: 'error',
      });
      return Promise.reject(new Error('导出失败'));
    }
  }

  return {
    ucantable,
    scantable,
    notInArraydata,
    audioSrc,
    loading,
    loading_out,
    scandata,
    sn,
    hw,
    total,
    unscan,
    scaned,
    useimportData,
    ScanEnter,
    useioutData
  }
})

export default useCounterStore